После изучения этого раздела вы научитесь разрабатывать программы, в которых обрабатываемые данные организованны в виде массивов. Массив это структурный тип данных, который позволяет объединить несколько логически связанных переменных общим именем. Причём в пределах массива каждая переменная имеет собственное имя – индекс. Но в отличие от имён простых переменных, значение индекса - это вычисляемое значение. Каждый массив характеризуется типом компонентов, размером и размерностью. Все компоненты массива имеют один тип. Типом компонентов массива может быть любой тип. Размер определяет количество компонентов в массиве. Размер массива нельзя изменить в процессе выполнения программы. Размерность массива определяется количеством индексов, с помощью которых переменная именуется в пределах массива. Индексы компонентов массива могут быть только выражениями целочисленного типа, начиная с 0.

Массивы позволяют обрабатывать данные, организованные в виде векторов, матриц, таблиц.

Пример 1. Вычисление среднего

Пускай вы осуществляли измерения напряжения в сети в течение недели. Получили 7 значений напряжения. Вы хотите провести статистическую обработку этих значений. Вам необходимо вычислить среднее значения напряжения в сети за неделю измерений.

Если вы захотите написать программу для выполнения этих вычислений, вам необходимо будет полученные значения сохранить в переменных. При использовании простых переменных вещественного типа вам понадобятся 7 переменных. Каждую переменную придётся поименовать. Все эти имена будут участвовать в выражениях для вычисления требуемых значений.

double U1,U2,…, U7, M,D;
M = (U1+ U2+ U3+…+U7)/7;

А, если измерений было бы 1000? Вот в таких ситуациях нам и помогают массивы или регулярные типы.

using System;

namespace Example_1
{
    class Program
    {
        static void Main(string[] args)
        {
            //Массив напряжений за неделю
            double[] U = new double[7];
            //Переменная для хранения среднего
            double M = 0;
            //Ввод значений в компоненты массива U с клавиатуры
            for (int i = 0; i < U.Length; i++)
            {
                Console.Write("U[{0}] = ", i);
                U[i] = Convert.ToDouble(Console.ReadLine());
            }
            //Суммируем компоненты массива
            for (int i = 0; i < U.Length; i++)
                M = M + U[i];
            //Вычисляем среднее
            M = M / U.Length;
            //Выводим среднее
            Console.WriteLine("M = {0,6:###.##}",M);
        }
    }
}

В этой программе мы сначала вводим значения напряжения в компоненты массива U с клавиатуры. Для этой цели мы организовали цикл for. Индекс цикла i пробегает значения от 0 до U.Length - 1. Индексация элементов массива начинается с 0, а свойство Length класса Array возвращает количество элементов массива U. Для вычисления среднего значения напряжения использовано единственное имя компонента массива U с индексом i – U[i], который при выполнении цикла будет пробегать значения от 1 до 7. U[i] – простая переменная вещественного типа, с ней мы можем работат, как с любой другой простой переменной вещественного типа. Таким образом, внутри цикла мы каждый раз вычисляем имя нового компонента массива и добавляем его значение к значению переменной M.

Результат работы программы:

Пример 2. Нахождение суммы положительных элементов одномерного массива

Написать и протестировать программу, которая в одномерном массиве A целых переменных находит сумму положительных компонентов.

Для нахождения суммы компонентов с положительными значениями необходимо перебрать все компоненты массива, начиная с первого. Значение компонента добавляется к сумме, если его значение – положительное. Перед началом цикла в значение суммы необходимо установить значение 0. Для просмотра значений компонентов массива необходимо организовать цикл. Для этой цели воспользуемся управляющей структурой FORDO.

Блок-схема решения представлена ниже на рисунке.

Пример консольного приложения, в котором вычисляется сумма положительных значений компонентов одномерного массива целых переменных, представлен ниже.

using System;

namespace Example_2
{
    class Program
    {
        static void Main(string[] args)
        {
            //Сумма положительных компонентов массива
            //компонентов в массиве
            double Sum = 0;
            //Массив, инициированный начальными значениями
            int[] A = { 1, 5, -3, 2, 7 };
            for (int I = 0; I < A.Length; I++ )
                    if (A[I] > 0) Sum = Sum + A[I];
            Console.WriteLine("Summa = " + Sum);
        }
    }
}

Пример работы программы:

Пример 3. Нахождение суммы положительных элементов двумерного массива

Написать и оттестировать программу вычисления суммы положительных компонентов двумерного массива A целых переменных.

Для нахождения суммы Sum положительных компонентов массива необходимо последовательно просмотреть все компоненты массива A. В качестве начального значения для Sum необходимо взять 0. Если значение очередного компонента A[I,J] массива A оказалось положительным, то его необходимо добавить к сумме Sum. Просматривать компоненты массива можно по строкам (I), а можно - по столбцам (J). Будем просматривать значения компонентов массива построчно: строки будем просматривать в сторону строк с большим значением индекса (I), а внутри строки столбцы будем просматривать в сторону столбцов с большим значением индекса(J) . Для этого нам понадобятся два цикла: один вложенный в другой. Внешний цикл изменяет значения индекса строки (I), внутренний – значение индекса столбца (J). Во внутреннем цикле к сумме добавляем значения положительных компонентов массива A[I,J]. Описанный алгоритм представлен блок-схемой, изображённой ниже.

Консольное приложение, отыскивающее сумму положительных компонентов двумерного массива целых переменных, представлено ниже.

using System;

namespace Example_3
{
    class Program
    {
        static void Main(string[] args)
        {
            //Сумма положительных компонентов массива
            int[,] A = { { 2, 3, 5 }, { 4, -3, 9 }, { 1, 8, 7 } };
            int Sum = 0;
            //Цикл по строкам
            for(int I = 0;I < A.GetLength(0); I++)
              //Цикл по //столбцам
              for(int J = 0; J < A.GetLength(1); J++)
                if(A[I, J] > 0) //Положительный компонент
                  Sum = Sum + A[I, J];
            Console.WriteLine("Summa = " + Sum);
        }
    }
}

Пример работы программы:

Пример 4. Перемножение матриц

Решение системы линейных уравнений

В качестве примера рассмотрим в общем виде систему линейных уравнений с тремя неизвестными, представленную ниже.

Эту систему линейных уравнений можно представить в матричной форме

AX = B,

где A – матрица коэффициентов, ,

B - столбец (вектор) свободных членов, ,

X - столбец (вектор) неизвестных, .

Решение системы уравнений в матричной форме имеет вид X = A^-1B, где A^-1 - обратная матрица к матрице А.

Пусть нам необходимо решить систему линейных уравнений, заданную матрицей коэффициентов A ,

и свободных членов B .

Для решения представленной системы уравнений с помощью программы, нам необходимо представить матрицу A и матрицы столбцы B, X в виде переменных. Для представления матриц столбцов B, X можно использовать одномерные массивы, для представления же матрицы коэффициентов A, A^-1 потребуются двумерные массивы. Предположим, что обратная матрица A^-1 найдена.

Блок-схема умножения обратной матрицы А^-1 (в блок-схеме она обозначена как A1) на вектор-столбец В будет иметь следующий вид.

Тогда программа для вычисления значений неизвестных X системы линейных уравнений будет выглядеть следующим образом:

using System;

namespace Example_4
{
    class Program
    {
        static void Main(string[] args)
        {
            //Массив для хранения матрицы коэффициентов
            double[,] A1 = { { 5, 7, 2 }, { 8, 1, 3 }, {4, 5, 9} };
            //Массив для хранения матриц-столбцов свободных членов
            double[]  B = { 3, 8, 5 };
            //вектор-столбец результатов
            double[] X = new double[3];
            for(int I = 0; I < A1.GetLength(0); I++)
            {
                X[I] = 0;
                for(int J = 0; J < A1.GetLength(1); J++)
                    X[I] = X[I] + A1[I, J] * B[J];
            } 
            for(int I = 0; I < X.Length; I++)
                Console.Write("\t{0},",X[I]);
            Console.WriteLine();
        }
    }
}

Пример работы программы:

Массив (регулярный тип) – это структура поименованных данных, которая представляет собой однородную, фиксированную по размеру и конфигурации совокупность переменных, упорядоченных по номерам.

Массив определяется именем – идентификатором, числом измерений и размерностью. Имя массива является единым для всех его элементов. Число измерений массива – это количество координат, необходимых для указания местонахождения требуемого элемента массива. Размерность массива – это количество компонент в составе переменной типа массив. Размерность массива определяется произведением числа значений по всем типам координат.

К отдельному компоненту массива можно обращаться с помощью одного или нескольких индексов, в зависимости от числа измерений массива. В качестве индексов могут использоваться выражения целочисленных типов. Элементами массивов могут быть как переменные любых типов.

Для работы с массивом необходимо:

• исходя из особенностей решаемой задачи и в соответствии с синтаксисом языка программирования, сконструировать и описать массив.

При работе с массивами вы можете:

• изменять значения отдельных компонент массива;

• копировать значения отдельных компонент массива;

• выполнять над значениями отдельных компонент массива действия, определенные на типе компонент – использовать компоненты массивов в составе выражений как простые переменные;

• в качестве индекса компонента массива можно использовать неотрицательные выражения целочисленного типа;

• переменной массиву присвоить значение другой переменной массива того же типа;

• инициировать массив при описании начальными значениями.

Массивы C#

Массив — это ограниченная совокупность однотипных величин. Элементы массива имеют одно и то же имя, а различаются по порядковому номеру ( индексу ).

Массив в С# относится к ссылочным типам данных, то есть располагается в динамической области памяти, поэтому создание массива начинается с выделения памяти под его элементы. Элементами массива могут быть величины как значимых, так и ссылочных типов (в том числе массивы). Массив значимых типов хранит значения, массив ссылочных типов — ссылки на элементы. Всем элементам при создании массива присваиваются значения по умолчанию: нули для значимых типов и null для ссылочных.

На рис. 6.1 представлен массив, состоящий из пяти элементов любого значимого типа, например, int или double, а рисунок 6.2 иллюстрирует организацию массива из элементов ссылочного типа.

Рис. 6.1. Простые переменные и массив из элементов значимого типа

Рис. 6.2. Массив из элементов ссылочного типа

Вот, например, как выглядят операторы создания массива из 10 целых чисел и массива из 100 строк:

int[] w = new int[10];
string[] z = new string[100];

В первом операторе описан массив w типа int[]. Операция new выделяет память под 10 целых элементов, и они заполняются нулями.

Во втором операторе описан массив z типа string[].Операция new выделяет память под 100 ссылок на строки, и эти ссылки заполняются значением null. Память под сами строки, составляющие массив, не выделяется — это будет необходимо сделать перед заполнением массива.

Количество элементов в массиве ( размерность ) не является частью его типа, оно задается при выделении памяти и не может быть изменено впоследствии. Размерность может задаваться не только константой, но и выражением. Результат вычисления этого выражения должен быть неотрицательным, а его тип должен иметь неявное преобразование к int, uint, long или ulong.

Элементы массива нумеруются с нуля, поэтому максимальный номер элемента всегда на единицу меньше размерности. Для обращения к элементу массива после имени массива указывается номер элемента в квадратных скобках, например:

w[4] z[i]

С элементом массива можно делать все, что допустимо для переменных того же типа. Если при работе с массивом значение индекса выходит за границы массива, генерируется исключение IndexOutOfRangeException.

Массивы одного типа можно присваивать друг другу. При этом происходит присваивание ссылок, а не элементов, как и для любого другого объекта ссылочного типа, например:

int[] a = new int[10];
int[] b = a; // b и a указывают на один и тот же массив

Все массивы в C# имеют общий базовый класс Array, определенный в пространстве имен System. В нем есть несколько полезных методов, упрощающих работу с массивами, например, методы получения размерности, сортировки и поиска. Мы рассмотрим эти методы немного позже в разделе "Класс System.Array".

В C# существуют три разновидности массивов: одномерные, прямоугольные и ступенчатые (невыровненные). О последних, менее распространенных, можно прочитать в учебнике (Павловская Т. А. С#. Программирование на языке высокого уровня. — СПб.: Питер, 2010), а сейчас займемся одномерными массивами.

Одномерные массивы

Одномерные массивы используются в программах чаще всего. Варианты описания массива:

тип[] имя;
тип[] имя = new тип [ размерность ];
тип[] имя = { список_инициализаторов };
тип[] имя = new тип [] { список_инициализаторов };
тип[] имя = new тип [ размерность ] { список_инициализаторов };

Примеры описаний (один пример на каждый вариант описания):

int[] a; // 1: элементов нет
int[] b = new int[4]; // 2: элементы равны 0
int[] c = { 61, 2, 5, -9 }; // 3: new подразумевается
int[] d = new int[ ] { 61, 2, 5, -9 }; // 4: размерность вычисляется
int[] e = new int[4] { 61, 2, 5, -9 }; // 5: избыточное описание

Здесь описано пять массивов. Отличие первого оператора от остальных состоит в том, что в нем фактически описана только ссылка на массив, а память под элементы массива не выделена.

В каждом из остальных массивов по четыре элемента целого типа. Как видно из операторов 3–5, массив при описании можно инициализировать. Если при этом не задана размерность (оператор 3), количество элементов вычисляется по количеству инициализирующих значений. Для полей объектов и локальных переменных можно опускать операцию new, она будет выполнена по умолчанию (оператор 2). Если присутствует и размерность, и список инициализаторов, размерность должна быть константой (оператор 4).

В качестве примера рассмотрим программу, которая определяет сумму и количество отрицательных элементов, а также максимальный элемент массива, состоящего из 6 целочисленных элементов (листинг 6.1).

using System;
namespace ConsoleApplication1
{    class Class1
    {
        static void Main()
        {
            const int n = 6;
            int[] a = new int[n] { 3, 12, 5, -9, 8, -4 };

            Console.WriteLine( "Исходный массив:" );
            for ( int i = 0; i < n; ++i )
                Console.Write( "\t" + a[i] );
            Console.WriteLine();

            long sum = 0;              // cумма отрицательных элементов
            int  num = 0;              // количество отрицательных элементов
            for ( int i = 0; i < n; ++i )
                if ( a[i] < 0 )
                {
                    sum += a[i];
                    ++num;
                }

            Console.WriteLine( "Сумма  отрицательных = " + sum );
            Console.WriteLine( "Кол-во отрицательных = " + num );

            int max = a[0];             // максимальный элемент
            for ( int i = 1; i < n; ++i )
                if ( a[i] > max ) max = a[i];

            Console.WriteLine( "Максимальный элемент = " + max );
        }
    }
}

Листинг 6.1. Работа с одномерным массивом

Обратите внимание, что для вывода массива требуется организовать цикл.

Прямоугольные массивы

Прямоугольный массив имеет более одного измерения. Чаще всего в программах используются двумерные массивы. Варианты описания двумерного массива:

тип[,] имя;
тип[,] имя = new тип [ разм_1, разм_2 ];
тип[,] имя = { список_инициализаторов };
тип[,] имя = new тип [,] { список_инициализаторов };
тип[,] имя = new тип [ разм_1, разм_2 ] { список_инициализаторов };

Примеры описаний (один пример на каждый вариант описания):

int[,] a; // 1 элементов нет
int[,] b = new int[2, 3]; // 2 элементы равны 0
int[,] c = {{1, 2, 3}, {4, 5, 6}}; // 3 new подразумевается
int[,] c = new int[,] {{1, 2, 3}, {4, 5, 6}}; // 4 размерность вычисляется
int[,] d = new int[2,3] {{1, 2, 3}, {4, 5, 6}};// 5 избыточное описание

К элементу двумерного массива обращаются, указывая номера строки и столбца, на пересечении которых он расположен, например:

a[1, 4] b[i, j] b[j, i]

Внимание

Необходимо помнить, что компилятор воспринимает как номер строки первый индекс, как бы он ни был обозначен в программе.

В качестве примера рассмотрим программу, которая для целочисленной матрицы размером 3 x 4 определяет среднее арифметическое ее элементов и количество положительных элементов в каждой строке.

Для нахождения среднего арифметического элементов массива требуется найти их общую сумму, после чего разделить ее на количество элементов. Порядок перебора элементов массива (по строкам или по столбцам) роли не играет. Нахождение количества положительных элементов каждой строки требует просмотра матрицы по строкам. Схема алгоритма приведена на рис. 6.3, программа — в листинге 6.2.

using System;
namespace ConsoleApplication1
{    class Class1
    {
        static void Main()
        {
            const int m = 3, n = 4;
            int[,] a = new int[m, n] {
                { 2,-2, 8, 9 }, 
                {-4,-5, 6,-2 },
                { 7, 0, 1, 1 } 
             };

            Console.WriteLine( "Исходный массив:" );
            for ( int i = 0; i < m; ++i )
            {
                for ( int j = 0; j < n; ++j )
                    Console.Write( "\t" + a[i, j] );
                Console.WriteLine();
            }

            double sum = 0;
            int nPosEl;
            for ( int i = 0; i < m; ++i )
            {
                nPosEl = 0;
                for ( int j = 0; j < n; ++j )
                {
                    sum += a[i, j];
                    if ( a[i, j] > 0 ) ++nPosEl;
                }
                Console.WriteLine( "В строке {0} {1} положит-х элементов", 
                    i, nPosEl  );
            }
            Console.WriteLine( "Среднее арифметическое всех элементов: " 
                + sum / m / n );
        }
    }
}

Листинг 6.2. Работа с двумерным массивом

В приведённом ниже примере отыскивается минимальное значение среди компонент двумерного массива.

using System;

namespace Min
{
    class Program
    {
        static void Main(string[] args)
        {
            //Число строк в массиве.
            const int rows = 3;
            //Число столбцов в массиве.
            const int cols = 3;
            //Двумерный массив.
            double[,] M = new double[rows, cols] 
            { 
                { 1, 2, 3 }, 
                { 4, -1, 5 }, 
                { 6, 7, 8 } 
            };
            double min = M[0, 0];
            for (int i = 0; i < rows; i++)
                for (int j = 0; j < cols; j++)
                    if (min > M[i, j]) min = M[i, j];
            Console.WriteLine("min = " + min);
        }
    }
}

Результат работы программы:

Ступенчатые массивы

В ступенчатых массивах количество элементов в разных строках может различаться. В памяти ступенчатый массив хранится иначе, чем прямоугольный: в виде нескольких внутренних массивов, каждый из которых имеет свой размер. Кроме того, выделяется отдельная область памяти для хранения ссылок на каждый из внутренних массивов (рис. 6.3).

Рис. 6.3. Ступенчатый массив

Ниже приведён пример ступенчатого массива nums:

int[][] nums = new int[3][];
nums[0] = new int[2];
nums[1] = new int[3];
nums[2] = new int[5];

Здесь две группы квадратных скобок указывают, что это массив массивов, то есть такой массив, который в свою очередь содержит в себе другие массивы. В данном случае у нас массив nums содержит три массива. Причем размерность каждого из этих массивов может не совпадать.

Причем мы можем использовать в качестве массивов и многомерные:

int[][,] nums = new int[3][,]
{
new int[,] { {1,2}, {3,4} },
new int[,] { {1,2}, {3,6} },
new int[,] { {1,2}, {3,5}, {8, 13} }
};

Так здесь у нас массив из трех массивов, причем каждый из этих массивов представляет двухмерный массив.

Некоторые методы и свойства массивов:

• Свойство Length: позволяет получить общее количество элементов массива по всем измерениям.

• Свойство Rank: позволяет получить число измерений массива

• Метод GetLength(i): позволяет получить размерность массива по заданному измерению i.

Примеры использования:

int[] nums1 =new int[] {8, 1, 5, 3, 4, 2};
int length = nums1.Length;
Console.WriteLine("количество элементов: {0}", length);
int rank = nums1.Rank;
Console.WriteLine("размерность массива: {0}", rank);
Array.Reverse(nums1);
Array.Sort(nums1);
Console.WriteLine(nums1[1]);

В приведённом ниже примере отыскивается сумма компонент ступенчатого двумерного массива.

int[] nums1 =new int[] {8, 1, 5, 3, 4, 2};
int length = nums1.Length;
Console.WriteLine("количество элементов: {0}", length);
int rank = nums1.Rank;
Console.WriteLine("размерность массива: {0}", rank);
Array.Reverse(nums1);
Array.Sort(nums1);
Console.WriteLine(nums1[1]);using System;

namespace Sum
{
    class Program
    {
        static void Main(string[] args)
        {
            double[][] M = new double[3][];
            M[0] = new double[3] { 1, 2, 3 };
            M[1] = new double[4] { 4, 5, 6, -1 };
            M[2] = new double[5] { 7, 8, 9, -3, 5 };
            double Sum = 0;
            for (int i = 0; i < M.GetLength(0); i++)
                for (int j = 0; j < M[i].Length; j++)
                    Sum += M[i][j];
            Console.WriteLine("Sum = {0}", Sum);
        }
    }
}

Результат работы программы:

В приведённом ниже примере отыскивается сумма компонент ступенчатого двумерного массива, лежащих на и выше побочной диагонали.

using System;

namespace Sum
{
    class Program
    {
        static void Main(string[] args)
        {
            double[][] M = new double[3][];
            M[0] = new double[3] { 1, 2, 3 };
            M[1] = new double[3] { 4, 5, 6 };
            M[2] = new double[3] { 7, 8, 9 };
            double Sum = 0;
            for (int i = 0; i < M.GetLength(0); i++)
                for (int j = 0; j < M[i].Length - i; j++)
                    Sum += M[i][j];
            Console.WriteLine("Sum = {0}", Sum);
        }
    }
}

Результат работы программы:

Фрагмент программы, иллюстрирующий работу со ступенчатым массивом, приведен в листинге 6.5 (после рассмотрения оператора foreach).

Класс System.Array

Все массивы в C# построены на основе базового класса Array, который содержит полезные для программиста свойства и методы, часть из которых перечислена в таблице 6.1.

Таблица 6.1. Некоторые элементы класса Array

В листинге 6.3 продемонстрировано применение элементов класса Array при работе с одномерным массивом.

using System;
namespace ConsoleApplication1
{    class Class1
    {   static void Main()
        {
            int[] a =  { 24, 50, 18, 3, 16, -7, 9, -1 };

            PrintArray( "Исходный массив:", a );
            Console.WriteLine( Array.IndexOf( a, 18 ) ); 

            Array.Sort(a);
            PrintArray( "Упорядоченный массив:", a );
            Console.WriteLine( Array.BinarySearch( a, 18) );
        }

        public static void PrintArray( string header, int[] a )
        {
            Console.WriteLine( header );
            for ( int i = 0; i < a.Length; ++i )
                Console.Write( "\t" + a[i] );
            Console.WriteLine();
        }
    }
}

Листинг 6.3. Использование методов класса Array с одномерным массивом

Методы Sort, IndexOf и BinarySearch являются статическими, поэтому к ним обращаются через имя класса, а не экземпляра, и передают в них имя массива. Двоичный поиск можно применять только для упорядоченных массивов. В классе Class1 описан вспомогательный статический метод PrintArray, предназначенный для вывода массива на экран.

Результат работы программы:

Исходный массив:
24 50 18 3 16 -7 9 -1
2
Упорядоченный массив:
-7 -1 3 9 16 18 24 50
5

Оператор foreach

Оператор foreach применяется для перебора элементов в специальным образом организованной группе данных. Массив является именно такой группой. Удобство этого вида цикла заключается в том, что нам не требуется определять количество элементов в группе и выполнять их перебор по индексу: мы просто указываем на необходимость перебрать все элементы группы. Синтаксис оператора:

foreach ( тип имя in выражение ) тело_цикла

Имя задает локальную по отношению к циклу переменную, которая будет по очереди принимать все значения из массива выражение (в качестве выражения чаще всего применяется имя массива или другой группы данных). В простом или составном операторе, представляющем собой тело цикла, выполняются действия с переменной цикла. Тип переменной должен соответствовать типу элемента массива.

Например, пусть задан массив:

int[] a = { 24, 50, 18, 3, 16, -7, 9, -1 };

Вывод этого массива на экран с помощью оператора foreach выглядит следующим образом:

foreach ( int x in a ) Console.WriteLine( x );

Этот оператор выполняется так: на каждом проходе цикла очередной элемент массива присваивается переменной х и с ней производятся действия, записанные в теле цикла.

В листинге 6.4 решается та же задача, что и в листинге 6.1, но с использованием цикла foreach. Обратите внимание, насколько понятнее стала программа.

using System;
namespace ConsoleApplication1
{   class Class1
    {   static void Main()
        {
            int[] a = { 3, 12, 5, -9, 8, -4 };

            Console.WriteLine( "Исходный массив:" );
            foreach ( int elem in a )
                Console.Write( "\t" + elem );
            Console.WriteLine();

            long sum = 0;              // cумма отрицательных элементов
            int  num = 0;              // количество отрицательных элементов
            foreach ( int elem in a )
                if ( elem < 0 )
                {
                    sum += elem;
                    ++num;
                }

            Console.WriteLine( "sum = " + sum );
            Console.WriteLine( "num = " + num );

            int max = a[0];            // максимальный элемент
            foreach ( int elem in a )
                if ( elem > max ) max = elem;

            Console.WriteLine( "max = " + max );
        }
    }
}

Листинг 6.4. Работа с одномерным массивом с использованием цикла foreach

Внимание

Ограничением оператора foreach является то, что с его помощью можно только просматривать значения в группе данных, но не изменять их.

Еще один пример использования оператора для работы со ступенчатым массивом приведен в листинге 6.5.

...
int[][] a = new int[3][];
          a[0] = new int [5] { 24, 50, 18, 3, 16 };
          a[1] = new int [3] { 7, 9, -1 };
          a[2] = new int [4] { 6, 15, 3, 1 };
          Console.WriteLine( "Исходный массив:" );
foreach ( int [] mas1 in a )
            {
                foreach ( int x in mas1 ) 
                       Console.Write( "\t" + x );
                Console.WriteLine();
            }
         // поиск числа 18 в нулевой строке:   
         Console.WriteLine( Array.IndexOf( a[0], 18 ) );
...

Листинг 6.5. Работа со ступенчатым массивом с использованием цикла foreach

Контрольные вопросы

1. Может ли массив содержать компоненты различных

2. Что необходимо для использования массивов в программах?

3. Какие действия допустимы над массивом?

4. Какие действия допустимы над компонентами массивом?

5. Каким может быть тип индекса массива?

6. Каким может быть тип компонентов массива?

7. Что такое размерность массива?

8. Что такое число измерений массива?

9. Чему равно количество компонентов массива?

10. Как строится имя компонента массива?

11. Можно ли в качестве индекса компонента массива использовать выражение?

12. Сколько индексов должно быть в имени компонента массива?

13. Где можно использовать имя компонента массива?

Источники дополнительных сведений

1. Павловская Т.А. C#. Программирование на языке высокого уровня :Учебник для вузов. - СПб. : Питер, 2014. - 432 с. : ил. - (Серия "Учебник для вузов").

2. Рихтер Дж. CLR via C#. Программирование на платформе Microsoft.NET Framework 4.0 на языке C# . 3-е изд.: - СПб.:Питер, 2012. - 928 с. : ил.